home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / dskut / dcopy332.zip / DCSOURCE.C < prev    next >
C/C++ Source or Header  |  1990-04-14  |  5KB  |  151 lines
  1. /*************************************************************
  2.  *                                                           *
  3.  * Program DCOPY - physical sector to sector copy              *
  4.  * Copyright (c) 1986 Joerg Genius, Munich, West-Germany     *
  5.  *                                                           *
  6.  * Rev. 3.1.1 fixed verify by supplying length to memcpy()   *
  7.  * Rev. 3.1.2 added /r command to verify only                *
  8.  *************************************************************/
  9.  
  10. #include <stdio.h>
  11. #include <alloc.h>
  12. #include <sys\types.h>
  13. #include <sys\stat.h>
  14. #include <io.h>
  15. #include "dcdefs.h"
  16.  
  17.  
  18. dfsource (f_name,von,nach,verify,nocompress)
  19.  
  20. int nach,verify,nocompress;
  21. FILE *von;
  22. char *f_name;
  23.  
  24.  
  25. {
  26.    unsigned char *ver_buffer;          /* one sector for verify */
  27.    struct drive_data dest;
  28.    unsigned int blcnt;
  29.    int error;
  30.    unsigned int subcnt;
  31.    unsigned char *freesec; /* SECTOR BITMAP */
  32.    unsigned char *freewhat;
  33.    unsigned int sec_maps;
  34.    unsigned int max_blocks;
  35.    int file_type;
  36.  
  37.  
  38.    if (verify!=0) {
  39.       if ((ver_buffer=malloc(512*blk_p_buffer))==NULL) {
  40.          fprintf (stderr,text[2]);
  41.          return (1);
  42.       }
  43.    }
  44.    if (get_drive_data(nach,&dest)!=0)
  45.       return (1);
  46.    if (nocompress==0 && blk_p_buffer>64)
  47.       blk_p_buffer=64;
  48.    max_blocks=get_max_blocks(dest.sec_p_drive);
  49.    if (nocompress) {
  50.       if ((int)(filelength(fileno(von))/512)!=dest.sec_p_drive) {
  51.          fprintf (stderr,text[20]);
  52.          return (1);
  53.       }
  54.    }
  55.    else {
  56.       if ((freesec=malloc((dest.sec_p_drive+7)/8))==NULL ||
  57.           (freewhat=malloc(dest.sec_p_drive))==NULL) {
  58.           fprintf (stderr,text[2]);
  59.          return (1);
  60.       }
  61.       sec_maps=(dest.sec_p_drive+7)/8;
  62.       if (fread(&file_type,2,1,von)!=1) {
  63.          fprintf (stderr,text[21]);
  64.          return (1);
  65.       }
  66.       if (file_type!=dest.sec_p_drive) {
  67.          fprintf (stderr,text[20]);
  68.          return (1);
  69.       }
  70.    }
  71.    printf (text[8],d_types[disk_type]);
  72.    if (verify!=2)
  73.       printf (text[22],dest.sec_p_drive,f_name,nach+'A');
  74.    else
  75.       printf (text[24],dest.sec_p_drive,f_name,nach+'A');
  76.    if (nocompress) {
  77.       for (blcnt=0;blcnt<dest.sec_p_drive;blcnt+=max_blocks) {
  78.          max_blocks=(blcnt+max_blocks>=dest.sec_p_drive ? dest.sec_p_drive-blcnt : max_blocks);
  79.          if (fread(disk_buffer,512,max_blocks,von)!=max_blocks) {
  80.             fprintf (stderr,text[21]);
  81.             return (1);
  82.          }
  83.          if (verify!=2) {
  84.             if ((error=write_block(nach,blcnt,max_blocks,disk_buffer))!=0) {
  85.                fprintf (stderr,text[16],error,err_text[error]);
  86.                return (1);
  87.             }
  88.          }
  89.          if (verify!=0) {
  90.             if ((error=read_block(nach,blcnt,max_blocks,ver_buffer))!=0) {
  91.                fprintf (stderr,text[17],error,err_text[error]);
  92.                return (1);
  93.             }
  94.             if (memcmp(disk_buffer,ver_buffer,512*max_blocks)!=0) {
  95.                fprintf (stderr,text[18]);
  96.                return (1);
  97.             }
  98.          }
  99.       }
  100.       if (verify!=2)
  101.          printf (text[23],dest.sec_p_drive,f_name,nach+'A');
  102.       else
  103.          printf (text[25],dest.sec_p_drive,f_name,nach+'A');
  104.       return (0);
  105.    }
  106.    if (fread(freesec,1,sec_maps,von)!=sec_maps) {
  107.       fprintf (stderr,text[21]);
  108.       return (1);
  109.    }
  110.    if (fread(freewhat,1,dest.sec_p_drive,von)!=dest.sec_p_drive) {
  111.       fprintf (stderr,text[21]);
  112.       return (1);
  113.    }
  114.    for (blcnt=0;blcnt<dest.sec_p_drive;blcnt+=max_blocks) {
  115.       max_blocks=(blcnt+max_blocks>=dest.sec_p_drive ? dest.sec_p_drive-blcnt : max_blocks);
  116.       for (subcnt=0;subcnt<max_blocks;subcnt++) {
  117.          if ((freesec[(blcnt+subcnt)/8] & (1<<((blcnt+subcnt)%8)))!=0) {
  118.             memset(&disk_buffer[512*subcnt],freewhat[blcnt+subcnt],512);
  119.      }
  120.      else {
  121.             if (fread(&disk_buffer[512*subcnt],1,512,von)!=512) {
  122.                printf (text[21]);
  123.                return(0);
  124.             }
  125.      }
  126.       }
  127.       if (verify!=2) {
  128.          if ((error=write_block(nach,blcnt,max_blocks,disk_buffer))!=0) {
  129.             fprintf (stderr,text[16],error,err_text[error]);
  130.             return (1);
  131.          }
  132.       }
  133.       if (verify!=0) {
  134.          if ((error=read_block(nach,blcnt,max_blocks,ver_buffer))!=0) {
  135.             fprintf (stderr,text[17],error,err_text[error]);
  136.             return (1);
  137.          }
  138.          if (memcmp(disk_buffer,ver_buffer,512*max_blocks)!=0) {
  139.             fprintf (stderr,text[18]);
  140.             return (1);
  141.          }
  142.       }
  143.    }
  144.       if (verify!=2)
  145.          printf (text[23],dest.sec_p_drive,f_name,nach+'A');
  146.       else
  147.          printf (text[25],dest.sec_p_drive,f_name,nach+'A');
  148.    return (0);
  149. }
  150.    
  151.